const express = require('express')
const fs = require('fs')
const router = express.Router()

const multer = require('multer')
const fileFilter = (request, file, callback) => {

    if (!file.originalname.match(/\.jpg$/)) {
        return callback(new Error('wrong type :'), false)
    }

    callback(null, true)
}
//使用multer 中间间 第一个参数dest: 存储的路径
// const upload = multer({dest: 'upload/'})
//可以选择第二个参数 配置更多的信息
const storage = multer.diskStorage({
    //两个参数
    //存储的位置
    destination(req, file, cb){
        cb(null, 'upload/')
    },
    //文件名字的确定
    filename(req, file, cb){
        cb(null, Date.now() + file.originalname)
    }
})
//使用第二个参数 storage
const upload = multer({storage})

//爬虫
const request = require('request')
const cheerio = require('cheerio')

const userInfo = require('../mongodb/userInfo.js')
const shopInfo = require('../mongodb/shop.js')
const stateInfo = require('../mongodb/stateInfo.js')
const orderInfo = require('../mongodb/order.js')
const couponInfo = require('../mongodb/coupon.js')

router.post('/upLoad', upload.single('file'), (req, res) =>{

    const url = 'http://localhost:3003/' + req.file.filename
    
    res.json({url})



    return
    upload.single('file')(req, res, (err) =>{
        if(err instanceof multer.MulterError){
            return res.json({"msg": "只能上传jpg格式的图片"})
        }else if(err){
            return res.json({"msg": "只能上传jpg格式的图片"})
        }
        const url = 'http://localhost:3003/' + req.file.filename
        res.json({url})
    })
})

router.post('/multiple', (req, res) =>{
    upload.array('file', 10)(req, res, (err) =>{

        if(err instanceof multer.MulterError){
            return res.json({"msg": "只能上传jpg格式的图片"})
        }else if(err){
            return res.json({"msg": "只能上传jpg格式的图片"})
        }
       
        //遍历保存url地址即可
        const urlArr = req.files.map(item =>{
            return 'http://localhost:3003/' + item.filename
        })
        
        //此时可以把这个存储在数据库

        res.json({urlArr})
    })
})

//当用户名或者商店名字改变 修改订单的相应数据
router.post('/changeO',  (req, res) =>{
    const {id, data} = req.body
    console.log('订单1')
    orderInfo.findOne({otherOrderId: id}, (err, findData) =>{
        //没有数据 就不需要修改了
        if(!findData) return res.json({"msg": "没有数据", "code": 1})
        console.log('订单2')
        orderInfo.updateMany({otherOrderId: id},{$set: data}, (err, upData) =>{

            if(upData.nModified === 0) return res.json({"msg": "订单修相应数据修改失败", "code": -1}) 
            console.log('订单3')
            res.json({"msg": "订单修相应数据改成功", "code": 1})
    
        })
    })
})

router.post('/changeC',  (req, res) =>{
    const {id, data} = req.body
    couponInfo.findOne({belong: id + 'b'}, (err, findData) =>{

         //没有数据 就不需要修改了
        if(!findData) return res.json({"msg": "没有数据", "code": 1})
        couponInfo.updateMany({belong: id + 'b'},{$set: data}, (err, upData) =>{

            if(upData.nModified === 0) return res.json({"msg": "优惠劵修相应数据修改失败", "code": -1}) 

            res.json({"msg": "优惠劵修相应数据改成功", "code": 1})
        })
    })
})

//只有修改用户名才需要
router.post('/changeS',  (req, res) =>{
    const {id, data} = req.body
    couponInfo.findOne({shopId: id}, (err, findData) =>{
        //没有数据 就不需要修改了
        if(!findData) return res.json({"msg": "没有数据", "code": 1})

        shopInfo.updateOne({shopId: id}, {$set: data}, (err, upData) =>{
            //此时更新失败 如果为0  说明没有该条信息 那就是新店铺 保存该新店铺

            if(upData.nModified === 0) return res.json({"msg": "商店statusName修改失败", "code": -1}) 

            res.json({"msg": "商店statusName修改成功", "code": 1})

        })
    })
})


//评论的发表
router.post('/changeGood', (req, res) =>{

    const {sname, data, foodMenu, commitFlag} = req.body


    shopInfo.findOne({sname}, (err, newData) =>{

        if(!newData) return res.json({"data": "goodMenu查找失败", "code": -1})

        const goodMenu = arrClone(newData.goodMenu)
        
        //进行相应的操作  两种操作
        //追加评论 计算当前的好评率 data.commitFlag 存在即为评论的发表
        if(commitFlag){

            //找到 当前食材所在的菜单栏的索引
            const commitIndex = goodMenu.findIndex(item =>{
                return item.title === foodMenu
            })


            //根据foodName找到当前食材
            const commitI = goodMenu[commitIndex].data.findIndex(item =>{
                return item.foodName === data.foodName
            })

            goodMenu[commitIndex].data[commitI].foodCommit.unshift({
                commit: data.foodCommit,//内容
                commitRate: data.foodRate,//好评还是差评
                commitName: data.commitName,//评论人用户名
                commitHImg: data.commitHImg,//评论人的头像
            })

            //计算处当前的好评率 找出当前的 没有评价四
            /*
                goodMenu[index].data[i].foodCommit
                    1 找出当前的差评条数 
                    2 总条数 - 差评条数 即为好评条数
                    3 好评率 = 此时只取整数parseInt(好评条数/总条数)*100 +%
            */
            
           const badLen = goodMenu[commitIndex].data[commitI].foodCommit.filter(item =>{
                return item.commitRate === '差评'
           }).length

           //总条数
           const totalLen = goodMenu[commitIndex].data[commitI].foodCommit.length
           //好评率
           const rate = parseInt(((totalLen - badLen)/totalLen)*100) + '%'

           goodMenu[commitIndex].data[commitI].foodCommitRate = rate

        //修改下单 数量     
        }else{

             //(1) 遍历data
             data.forEach((items, index) =>{
                 //找到当前的菜单的索引
                 const goodIndex = goodMenu.findIndex(item =>{
                     return items.title === item.title
                 })
                 //遍历 data当前的菜单 找到具体的食材
                 if(goodIndex === -1) return//找不到就不要在往下执行了
                 //找到 就遍历
                 items.foodData.forEach((value, i) =>{
                     //遍历当前goodMenu的data 找到具体的下单食材
                    const foodIndex = goodMenu[goodIndex].data.findIndex(val =>{
                        return value.foodName === val.foodName
                    })

                    //找不到就直接return
                    if(foodIndex === -1) return
                    //否则继续执行 往当前食材的销售总数data.foodTotal + 当前的下单数量
                    goodMenu[goodIndex].data[foodIndex].foodTotal += value.foodTotal

                 })
             })

            /*  修改的是 goodMenu[index].data[i].foodTotal
                   找出当前的食材 在data的foodTotal 基础上在加上当前下单的数量即可
                    但是可能下单的种类不止一种：
                        1 客户端传过来的data数据格式
                            data:[
                                {
                                    title: '爆炒',
                                    foodData:[
                                        {foodName: 烧猪, foodTotal: 3},
                                        {foodName: 烤鸭, foodTotal: 10},
                                    ]
                                },
                                {
                                    title: '面条',
                                    foodData:[
                                        {foodName: 水煮面, foodTotal: 1},
                                        {foodName: 拉面, foodTotal: 2},
                                    ]
                                }
                            ]
                            [
                                {title: '爆炒', foodData:[{foodName: '烧猪', foodTotal: 3}]}
                            ]
                        2 步骤：
                            1 先遍历goodMenu 找出顾客购买的的title(所属 的菜单)
                            2 在遍历当前 菜单的data 找出顾客购买的具体食材
                            3 找到了 就获取当前食材用户下单的数量 + 当前食材的具体数量即可
            */
          



        }

        //统一更新
        shopInfo.updateOne({sname}, {$set: {goodMenu}}, (err, upData) =>{
            if(upData.nModified === 0) return res.json({"data": "goodMenu修改失败", "code": -1})
            res.json({"data": "goodMenu修改成功", "code": 1})
        })
    })
})

//优惠卷的 发放 和领取
//店家发放优惠卷
router.post('/sendCoupon', (req, res) =>{
    
    couponInfo.create(req.body, (err, newData) =>{
        if(!newData) return res.json({"data": "发放失败", "code": -1})

        res.json({data: req.body, "code": 1})       
    })
})
//店家删除优惠卷  其实就是更新 couponStatus为3 的状态
router.post('/removeCoupon', (req, res) =>{
    const { couponFlag, data} = req.body

    couponInfo.updateMany({couponFlag},{$set: data}, (err, newData) =>{
        if(newData.nModified === 0) return res.json({"msg": "删除失败", "code": -1})

        res.json({"msg": "删除成功", "code": 1})
    })
})


//顾客删除优惠卷 也没有删除 设置状态为 couponStatus为4
router.post('/delectCoupon', (req, res) =>{

    const { couponFlag, couponId, data} = req.body

    //购物车 顾客删除优惠劵使用了更新操作
    couponInfo.updateOne({couponFlag, couponId}, {$set: data}, (err, newData) =>{
        if(newData.nModified === 0) return res.json({"meg": "删除或者购物车使用失败失败", "code": -1})

        res.json({"data": "msg", "code": 1})
    })
})


//顾客领取优惠卷
router.get('/takeCoupon', (req, res) =>{
    const {couponId, couponSign} = req.query
     /* 
        目的：获取顾客领取的优惠卷和没有领取的优惠卷的集合
            这里 是获取优惠卷 并且筛选 处当前用户已经领取的优惠卷
                1 先获取店主的所有优惠卷 如果此时店主没有优惠卷 也就没必要往下执行
                    (1) 先获取店主的优惠卷 (couponId获取) 优惠卷为 空 return sCoupon
                    (2) 再获取当前用户在该店领取的优惠卷 通过 (couponSign获取) uCoupon
                    (3) 使用filter 过滤 sCoupon 在里面通过uCoupon调用findIndex方法
                    (4) 通过比较 couponFlag是否相同, 相同 则说明 该用户已经领取该优惠卷，findIndex返回相应的索引
                        否则 该顾客没有领取该优惠卷 此时我想要得到此时sCoupon的元素 findIndex返回 -1
                    (5) 判断 findIndex返回的值如果等于 -1 则rentun出去  
                    (6) 再把uCoupon与newSCoupon数组拼接即可
       */

    //(1)
    couponInfo.find({couponId}, {
        _id: 0,
        __v: 0,
    }, (err, sCoupon) =>{
        //没有优惠卷
        if(sCoupon.length <= 0) return res.json({"data": "没有优惠劵", "code": -1})

        //否则找出 用户的领取的优惠卷
        //(2)
        couponInfo.find({couponSign}, {
            _id: 0,
            __v: 0
        }, (err, uCoupon) =>{

            //(3) 调用filter方法 和findIndex方法
            let newSCoupon = sCoupon.filter((item, index) =>{
                //(4)遍历uCoupon 比较 couponFlag
                const findIndex = uCoupon.findIndex((val, i) =>{
                    
                    //(4)判断 val.couponFlag === item.couponFlag
                    return val.couponFlag === item.couponFlag
                })

                //(5) 判断findIndex的值是否为 -1 说明此时 该优惠卷该顾客没有领取
                if(findIndex === -1) return item
            })

            //(6)数组拼接 此时 uCoupon即为我们要的数据
            // uCoupon = newSCoupon.concat(uCoupon)
            res.json({"data": newSCoupon.concat(uCoupon), "code": 1})
        })
    })
})

//拿取优惠劵
router.get('/getCoupon', (req, res) =>{
    const {couponId} = req.query
    couponInfo.find({couponId},
        {
            _id: 0,
            __v: 0
        }, (err, data) =>{
        if(data.length === 0) return res.json({"data": "没有优惠劵", "code": -1})
        
        res.json({data, "code": 1})
    })
})





//存储订单
router.post('/saveOrder', (req, res) =>{
    orderInfo.create(req.body, (err, data) =>{
        return res.json({"msg": "保存成功", "code": 1})
    })
})


//店主拿取订单信息
router.get('/getOrder', (req, res) =>{
    const {orderGet, orderState} = req.query
    orderInfo.find({orderGet, orderState},{
        _id: 0,
        __v: 0,
    }, (err, data) =>{

        if(data.length === 0) return res.json({"data": "暂无数据", "code": -1})

        res.json({data, "code": 1})
    })
})

//统一修改订单信息
router.post('/changeOrder', (req, res) =>{

    const {oFlag, data} = req.body

    orderInfo.updateMany({oFlag},{$set: data}, (err, upData) =>{

        if(upData.nModified === 0) return res.json({"data": "店主修改失败", "code": -1})

        res.json({"data": "大家都修改成功", "code": 1})

    })
})


//删除商店信息
router.get('/removeShop', (req, res) =>{

    /*
        客户端需要传入三个数据
            belong: 修改优惠劵的状态 顾客领取的优惠劵
            uname:  删除商店 以及商家的优惠劵
     */

    const {shopId} = req.query
    shopInfo.deleteOne({shopId}, (err, data) =>{
      if(data.deletedCount === 0) return res.json({"data": "破产失败", "code": -1})
      // 表示删除成功 
      //删除商家的优惠劵
      couponInfo.deleteMany({couponId: shopId}, (err, data) =>{
        //删除失败
        if(data.deletedCount === 0) return res.json({"data": " 商家优惠劵更新失败", "code": 1})
        //删除成功

        //更新顾客优惠劵 此时只更新 商家的以及couponStatus为1  没有使用过的即可
        couponInfo.updateMany({belong: shopId + 'b', couponStatus: 1},{$set: {couponStatus: 3}}, (err, upData) =>{
            if(upData.nModified === 0) return res.json({"data": " 顾客优惠劵更新失败", "code": 1})
            
            res.json({"data": "破产成功", "code": 1})
            
        })

      })
    })
})

//----------------------------------------------------商家
router.post('/saveShop', (req, res) =>{

    shopInfo.create(req.body, (err, data) =>{
        return res.json({"msg": "创建成功", "code": 1})
    })
})

//拿取商店信息
router.get('/getShop', (req, res) =>{
    const {shopId} = req.query
    shopInfo.findOne({shopId}, (err, data) =>{
        if(!data) return res.json({"msg": "店铺不存在", "code": -1})
        
        res.json({data, "code": 1})
    })
})

//验证当前的商铺是否存在 还是已经破产
router.get('/checkShop', (req, res) =>{
    const {shopId} = req.query

    shopInfo.find({shopId}, (err, data) =>{

        if(data.length > 0) return res.json({"data": "存在", "code": 1})

        res.json({"msg": "不存在", "code": -1})
    })
})


//修改商店食材的数据
router.post('/removeShopInfo', (req, res) =>{ 

    const {shopId, data} = req.body
    shopInfo.findOne({shopId}, (err, goodData) =>{
        //此时更新失败 如果为0  说明没有该条信息 那就是新店铺 保存该新店铺

        if(!goodData) return res.json({"msg": "修改失败", "code": -1})

        const {goodMenu} = goodData

        const {changeInfo, foodIndex, index} = data
         //存在着说明 删除食材
        if(index >=0){  
            if(!changeInfo) {//有值即为修改
                goodMenu[foodIndex].data.splice(index, 1)

            //编辑食材
            }else{
                for(let item in changeInfo){
                    goodMenu[foodIndex].data[index][item] = changeInfo[item]
                }
            }
        }else{
            //这里删除 菜单栏
            if(!changeInfo) {//有值即为修改
                goodMenu.splice(foodIndex, 1)
            }else{
                goodMenu[foodIndex].title = changeInfo
            }
        }

        shopInfo.updateOne({shopId}, {$set: {goodMenu}}, (err, upData) =>{
            if(upData.nModified === 0) res.json({"msg": "修改失败", "code": -1})
            
            res.json({"msg": "修改成功", "code": 1})
        })
    })
})
router.post('/changeFood', (req, res) =>{ 
    //注意修改的时候需要传 data的形式  第一次存储不需要       
    const {shopId, data} = req.body

    shopInfo.findOne({shopId}, (err, goodData) =>{
        //此时更新失败 如果为0  说明没有该条信息 那就是新店铺 保存该新店铺

        if(!goodData) return res.json({"msg": "修改失败", "code": -1})

        const {goodMenu} = goodData

        //存在着说明修改食材  0也是false
        if(data.foodIndex >= 0){
            goodMenu[data.foodIndex].data.unshift(data.changeInfo)
        }else{
            //这里修改菜单栏
            goodMenu.unshift(data.changeInfo)
        }

        shopInfo.updateOne({shopId}, {$set: {goodMenu}}, (err, upData) =>{
            if(upData.nModified === 0) res.json({"msg": "修改失败", "code": -1})
            
            res.json({"msg": "修改成功", "code": 1})
        })
    })
})

router.post('/changeShopLogin', (req, res) =>{
    const {shopId, data} = req.body
    shopInfo.updateOne({shopId},{$set: data}, (err, upData) =>{

        if(upData.nModified === 0) return res.json({"msg": "修改失败", "code": -1}) 

        res.json({"msg": "修改成功", "code": 1})

    })

})

//没有账号直接注册登陆
router.post('/register', (req, res) =>{
    const {uname} = req.body

    userInfo.find({uname}, (err, data) =>{
        if(data.length > 0) return res.json({"msg": "用户名存在", "code": -1})
        userInfo.create(req.body, (err, data) =>{
            return res.json({"storeFlag": data._id, "code": 1})
        })
    })
})

//登陆
router.get('/login', (req, res) =>{
    const {uname, paw} = req.query
    userInfo.findOne({uname}, (err, data) =>{
        if(!data) return res.json({"msg": "用户名不存在1", "code": -1})
        //密码验证
        if(data.paw != paw) return res.json({"msg": "密码错误1", "code": -2})

        res.json({"storeFlag": data._id, "code": 1})
    })
})

//修改用户的注册信息
router.post('/changeLogin', (req, res) =>{

    const {_id, data} = req.body

    if(!data.changeUname){
        userInfo.updateOne({_id}, {$set: data}, (err, dataInfo) =>{
        
            //说明修改失败
            if(dataInfo.nModified === 0) return res.json({"data": "修改失败", "code": -1})
    
            // 修改成功后不需要返回数据 直接 设置vuex的状态即可
            res.json({data, "code": 1})
    
        })

        return
    }


    userInfo.find({uname: data.uname}, (err, oldData) =>{
        //说明 新的用户名已经存在
        if(oldData.length > 0) return res.json({"msg": "用户名存在", "code": -2})
        
        //说明不存在 更新用户名
        userInfo.updateOne({_id}, {$set: {uname: data.uname}}, (err, dataInfo) =>{

            //说明修改失败
            if(dataInfo.nModified === 0) return res.json({"data": "用户名修改失败", "code": -1})
            // 修改成功后不需要返回数据 直接 设置vuex的状态即可
            res.json({data, "code": 1})
    
        })
    })
})

router.post('/saveState', (req, res) =>{
    const {storeFlag, uname, state} = req.body
    stateInfo.findOne({storeFlag}, (err, data) =>{
        if(data){
            
            stateInfo.updateOne({storeFlag}, {$set:{storeFlag, uname, state}}, (err, data) =>{        
                res.json({"msg": "state数据更新成功", "code": 1})        
            })
            return
        }

        //保存数据
        stateInfo.create(req.body, (err, data) =>{
            return res.json({data, "code": 1})
        })
      
    })
})

router.get('/getState', (req, res) =>{
    const {storeFlag} = req.query
    stateInfo.findOne({storeFlag}, (err, data) =>{
        if(!data) return res.json({"msg": "登陆失败", "code": -1})

        res.json({"data": data.state, "code": 1})
    })
})

//首页渲染商店数据
router.get('/homeShop', (req, res) =>{
    shopInfo.find({}, {
        _id: 0,
        _v: 0
    }, (err, data) =>{

        res.json({data, "code": 1})

    }).limit(20)
})

//首页渲染商店数据
router.get('/homeSeach', (req, res) =>{
    const {sname} = req.query
    const reg = new RegExp(sname)
    shopInfo.find({}, {
        _id: 0,
        __v: 0 
    }, (err, data) =>{

        let newData = []
        data.forEach(value => {
            if(reg.test(value.sname)) {
                newData.push(value)
            }
        })

        if(newData.length === 0) return res.json({"data": "暂无数据", "code": -1})

        res.json({"data": newData, "code": 1})
    })
})



  //数组深度拷贝
function arrClone(arr){

    let newArr = []
    
    for(let item of arr){	

        let newObj = {}
        for(let key in item){												
            
            if (Object.prototype.toString.call(item[key]) === "[object Array]") {
                
                newObj[key] = item[key].slice(0)							
                                                                                                    
            }else{
                //如果不是数组 就直接push
                newObj[key] = item[key]							
            }						
        }
        
        newArr.push(newObj)	
        
    }

    return newArr

}




module.exports = router